/**
 *
 * 1.元祖：可以用来包含一组不同类型的值
 * 2.Map的两种方式声明
 *   val/var map = Map(键->值, 键->值, 键->值...)    // 推荐，可读性更好
 *   val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)//元组方式
 * 3.List的创建方法
 *
 *   val/var 变量名 = List(元素1, 元素2, 元素3...)
 *   //使用 Nil 创建一个不可变的空列表
 *   val/var 变量名 = Nil
 *   //使用 :: 方法创建一个不可变列表
 *   val/var 变量名 = 元素1 :: 元素2 :: Nil
 *
 *4种操作符的区别
 * :: 该方法被称为cons，意为构造，向队列的头部追加数据，创造新的列表。用法为 x::list,其中x为加入到头部的元素，无论x是列表与否，
 *     它都只将成为新生成列表的第一个元素，也就是说新生成的列表长度为list的长度＋1(btw, x::list等价于list.::(x))
 * :+和+: 两者的区别在于:+方法用于在尾部追加元素+:方法用于在头部追加元素，和::很类似，
 *   但是::可以用于pattern match ，而+:则不行. 关于+:和:+,只要记住冒号永远靠近集合类型就OK了。
 * ++ 该方法用于连接两个集合，list1++list2
 * ::: 该方法只能用于连接两个List类型的集合
 *
 * Array和List通用方法:
 * take
 * takeRight
 * drop
 * dropRight
 * filter
 * map
 * sortBy
 * intersect
 * union
 * diff
 * sum
 * max
 * min
 * count
 * mkString
 * foreach
 * head 返回元素，有别与take(1)
 * last 返回元素，有别于takeRight(1)
 * exists
 * map
 * filter
 * mapValues :map才有
 * flatMap 扁平化Map
 **
 *重点：map      filter  sortBy   mapValues
 *flatMap  reduce  groupBy
*/

  println("Welcome to the Scala worksheet")
	//--------------List------------------
	val l1 = List(1,2,3,4)
//转换成字符串并且以逗号分割
l1.mkString(",")
val list22 = 1 :: (2 :: (3 :: (4 :: Nil)))
val list33 = 1 :: 2 :: 3 :: 4 :: Nil
// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
  (0 :: (1 :: (0 :: Nil))) ::
  (0 :: (0 :: (1 :: Nil))) :: Nil

	//变长
	val l2 = scala.collection.mutable.ListBuffer(1,2,3,4)
  //添加单个元素
  l2 +=5
  //添加一个不可变的列表
  l2 ++=List(6,7)
  //添加一个可变的列表
  l2 ++=scala.collection.mutable.ListBuffer(8,9)
  //删除单个元素
  l2 -=9
  //删除一个不可变的列表存在的元素
  l2 --=List(7,8)
  //删除一个可变的列表存在的元素
  l2 --=scala.collection.mutable.ListBuffer(5,6)
	
	l1(0)
	l1.apply(0)
	
	l1.foreach((x:Int)=> println(x))
  //简写
  l1.foreach(x=> println(x))
  //简写
  l1.foreach(println(_))
  //简写
  l1.foreach(println)

	l1.head
	l1.take(1)
	//是否存在
	l1.exists{x => x%2 == 0}
  l1.exists(_ %2 == 0)
	//追加元素，并返回List
	val r1 = l1.::(5)
	
	//类型转换
	val a1 = l1.toArray
	val a2 = a1.toList
	val i1 = 100
	val i2 = i1.toString()
	val i3 = i2.toInt
	
	//------------set----------
	//定长
	val s1 = Set(1,1,1,3)
  //加一个元素 本身是不变的，只是生成了一个新的集合
  val s11 = s1 + 6
  //减一个元素 本身是不变的，只是生成了一个新的集合
  val s12 = s1 - 1
	//变长
  val s2 = scala.collection.mutable.Set(1,1,1,3)
  //减一个元素 本身是不变的，只是生成了一个新的集合
  val s21 = s2 + 6
 //减一个元素 本身是不变的，只是生成了一个新的集合
  val s22 = s2 - 1
  s2
  //交集
  s1.intersect(s2)
  s1&s2
  //并集
  s1.union(s2)
  s1++s2
  //差集
  s1.diff(s2)
  s1&~s2

//添加单个元素
s2 +=6
//添加多个元素
s2 +=(6,7,8,9)
//添加一个set集合中的元素
s2 ++=Set(10,11)
//删除一个元素
s2 -=11
//删除多个元素
s2 -=(9,10)
//删除一个set子集
s2 --=Set(7,8)


  //------------Map----------
  val m1 = Map("tom"->23,"rose"->26,"lily"-> 40)

  //变长
  val m2 = scala.collection.mutable.Map("tom"->23,"rose"->26,"lily"-> 40)


  //追加
  m2 += ("tom2"->22)
  m2 -= ("rose")
  //key获取value
  m2.apply("tom")
  m2("tom")
  //key不存在可以返回默认值0
  m2.get("tom").getOrElse(0)
  //key的迭代器
  m1.keys
  //key的迭代器
  m1.keySet
  //value的迭代器
  m1.values
  //mapValue的映射
  val r11 = m1.mapValues{x=> x+10}

  //map的映射
  val r22 = m1.map{case(k,v) =>(k,v+4)}

  //x是一个元组，所以可以这样操作
  val r24 = m1.map{x =>(x._1,x._2+4)}

   //map的映射
  val r23 = m1.filter{case(k,v) =>v > 30}
  
  //-----------Tuple（元组）：最常用和最灵活的-
  val t1 = (1,2,3,4)


  val t2 = ("hello",100,Array(1,2,3),List(2,3,4,5))


  val t3 = ((1,2,3),("hello","world"),Array(2,3,4))


   //取值
  val v1=  t1._1
  val v2=  t1._2
  val v4 = t3._2._1
  val v5 = t3._3(2)
  
